data.framedata.frameL’une des classes S3 importante dans est la classe data.frame (tibble dans le “tidyverse”), qui repose entièrement sur les listes.
Qu’est-ce qu’un data.frame ?
Un data.frame est une liste nommée, de vecteur de même dimension (longueur) avec des attributs names (noms des colonnes) et row.names.
df1 <- data.frame(x = 1:3, y = letters[1:3]) typeof(df1)
#> [1] "list"
data.frameL’une des classes S3 importante dans est la classe data.frame (tibble dans le “tidyverse”), qui repose entièrement sur les listes.
Qu’est-ce qu’un data.frame ?
Un data.frame est une liste nommée, de vecteur de même longueur avec des attributs names (noms des colonnes) et row.names.
attributes(df1)
#> $names #> [1] "x" "y" #> #> $class #> [1] "data.frame" #> #> $row.names #> [1] 1 2 3
data.frameUn data.frame a donc une structure rectangulaire et dispose de noms pour les lignes et les colonnes.
rownames() pour obtenir le noms des lignes.colnames() (ou names()) pour obtenir le noms des colonnes.nrow() pour obtenir le nombre de lignes.ncol() (ou length()) pour obtenir le nombre de colonnes.data.frameLa création d’un data.frame se fait via data.frame().
df <- data.frame(
x = 1:3,
y = c("a", "b", "c")
)
str(df)
#> 'data.frame': 3 obs. of 2 variables: #> $ x: int 1 2 3 #> $ y: chr "a" "b" "c"
data.frameLa création d’un data.frame se fait via data.frame().
df <- data.frame(
x = 1:3,
y = c("a", "b", "c"),
stringsAsFactors = TRUE # Par défaut dans R < 4.0
)
str(df)
#> 'data.frame': 3 obs. of 2 variables: #> $ x: int 1 2 3 #> $ y: Factor w/ 3 levels "a","b","c": 1 2 3
data.frameLa création d’un data.frame se fait via data.frame().
df <- data.frame(
x = 1:3,
y = c("a", "b", "c"),
stringsAsFactors = FALSE # Par défaut dans R > 4.0
)
str(df)
#> 'data.frame': 3 obs. of 2 variables: #> $ x: int 1 2 3 #> $ y: chr "a" "b" "c"
data.framePar défaut, un data.frame requiert des noms de colonnes syntaxiquement correct.
names(data.frame(`1` = 1))
#> [1] "X1"
names(data.frame(`1` = 1, check.names = FALSE))
#> [1] "1"
data.frameUn data.frame requiert que ces éléments soit de même longueur, quand cela n’est pas respecté et lorsque c’est possible, les valeurs des vecteurs les plus courts sont recyclés.
data.frame(x = 1:4, y = 1:2)
#> x y #> 1 1 1 #> 2 2 2 #> 3 3 1 #> 4 4 2
data.frame(x = 1:4, y = 1:3)
#> Error in data.frame(x = 1:4, y = 1:3): arguments imply differing number of rows: 4, 3
data.frameLes data.frame ayant des noms de lignes, il est possible de les définir de plusieurs façons.
df3 <- data.frame(
age = c(35, 27, 18),
hair = c("blond", "brown", "black"),
row.names = c("Bob", "Susan", "Sam")
)
df3
#> age hair #> Bob 35 blond #> Susan 27 brown #> Sam 18 black
data.frameLes data.frame ayant des noms de lignes, il est possible de les définir de plusieurs façons.
df3 <- data.frame(
age = c(35, 27, 18),
hair = c("blond", "brown", "black")
)
rownames(df3) <- c("Bob", "Susan", "Sam")
df3
#> age hair #> Bob 35 blond #> Susan 27 brown #> Sam 18 black
data.frameL’usage des noms de lignes n’est pas recommandé.
Le nom des lignes est une donnée, pourquoi la stocker différemment ?
Le nom des lignes doit obligatoirement être une chaîne de caractères.
Chaque nom de ligne doit-être unique. s’assurera que ce soit le cas !
df3[c(1, 1, 1), ]
#> age hair #> Bob 35 blond #> Bob.1 35 blond #> Bob.2 35 blond
is.data.frame() permet de tester si l’objet est un data.frame() quand as.data.frame() permet la conversion.
is.data.frame(df1)
#> [1] TRUE
Est-il possible d’avoir un data.frame avec zéro lignes ? Et zéro colonnes ?
Que se passe-t-il lorsque des noms lignes avec duplicatas sont définis via rownames() ?
Que donne t(df) ou t(t(df)) ? Avec, df un objet de classe data.frame.
Que fait as.matrix() sur un data.frame dont les colonnes sont de type différents ?
NULLNULL un objet particulier.
typeof(NULL)
#> [1] "NULL"
length(NULL)
#> [1] 0
x <- NULL attr(x, "y") <- 1
#> Error in attr(x, "y") <- 1: attempt to set an attribute on NULL
NULLIl est possible de tester le caractère NULL d’un objet.
is.null(NULL)
#> [1] TRUE
NULL sert à définir :
un vecteur vide (p.ex., c().
un vecteur absent (p.ex., argument non défini d’une fonction).
x <- c(2.1, 4.2, 3.3, 5.4)
x[c(3, 1)]
#> [1] 3.3 2.1
x[c(1, 1)]
#> [1] 2.1 2.1
x[c(2.1, 2.9)] # Troncature
#> [1] 4.2 4.2
x <- c(2.1, 4.2, 3.3, 5.4)
x[-c(3, 1)]
#> [1] 4.2 5.4
x[c(-1, 2)] # Pas de mélange
#> Error in x[c(-1, 2)]: only 0's may be mixed with negative subscripts
x <- c(2.1, 4.2, 3.3, 5.4)
x[c(TRUE, TRUE, FALSE, FALSE)]
#> [1] 2.1 4.2
x[x > 3]
#> [1] 4.2 3.3 5.4
x <- c(2.1, 4.2, 3.3, 5.4)
x[c(TRUE, FALSE)] # Recyclage
#> [1] 2.1 3.3
x[c(TRUE, FALSE, TRUE, FALSE)]
#> [1] 2.1 3.3
x <- c(2.1, 4.2, 3.3, 5.4)
x[c(TRUE, TRUE, NA, FALSE)]
#> [1] 2.1 4.2 NA
x <- c(2.1, 4.2, 3.3, 5.4)
x[]
#> [1] 2.1 4.2 3.3 5.4
x <- c(2.1, 4.2, 3.3, 5.4)
x[0]
#> numeric(0)
x <- c(2.1, 4.2, 3.3, 5.4) names(x) <- letters[1:4]
x[c("d", "c", "a")]
#> d c a #> 5.4 3.3 2.1
x[c("a", "a", "a")]
#> a a a #> 2.1 2.1 2.1
z <- c(abc = 1, def = 2)
z[c("a", "d")] # Correspondance parfaite
#> <NA> <NA> #> NA NA
z[c("abc", "def")]
#> abc def #> 1 2
La sélection s’opère de la même façon que sur un vecteur.
[, renvoi une liste.[[ et $, renvoient un élément d’une liste.La sélection s’opère de la même façon que sur un vecteur.
[, renvoi une liste.
x <- list(2.1, 4.2, 3.3, 5.4) x[c(1, 3)]
#> [[1]] #> [1] 2.1 #> #> [[2]] #> [1] 3.3
x[[2]]
#> [1] 4.2
La sélection s’opère de la même façon que sur un vecteur.
[[ et $, renvoient un élément d’une liste.
x <- list(2.1, 4.2, 3.3, 5.4) names(x) <- letters[1:4] x$a
#> [1] 2.1
x[["b"]]
#> [1] 4.2
La sélection peut s’effectuer avec un vecteur, plusieurs vecteurs ou une matrice.
a <- matrix(1:9, nrow = 3)
colnames(a) <- c("A", "B", "C")
a[1:2, ]
#> A B C #> [1,] 1 4 7 #> [2,] 2 5 8
a[c(TRUE, FALSE, TRUE), c("B", "A")]
#> B A #> [1,] 4 1 #> [2,] 6 3
Comme les matrices ou arrays ne sont que des vecteurs avec un attribut dim, la sélection peut se faire directement avec un seul vecteur de position.
vals <- outer(1:5, 1:5, FUN = "paste", sep = ",") vals
#> [,1] [,2] [,3] [,4] [,5] #> [1,] "1,1" "1,2" "1,3" "1,4" "1,5" #> [2,] "2,1" "2,2" "2,3" "2,4" "2,5" #> [3,] "3,1" "3,2" "3,3" "3,4" "3,5" #> [4,] "4,1" "4,2" "4,3" "4,4" "4,5" #> [5,] "5,1" "5,2" "5,3" "5,4" "5,5"
vals[c(4, 15)]
#> [1] "4,1" "5,3"
Il est également possible d’effectuer la sélection à partir d’une matrice donnant la position des dans chacune des dimensions de la matrice ou array que l’on souhaite manipuler.
vals <- outer(1:5, 1:5, FUN = "paste", sep = ",") select <- matrix(ncol = 2, byrow = TRUE, c( 1, 1, 3, 1, 2, 4 )) vals[select]
#> [1] "1,1" "3,1" "2,4"
data.frameLes data.frame se comportent comme des listes et comme des matrices.
df <- data.frame(x = 1:3, y = 3:1, z = letters[1:3]) df[df$x == 2, ]
#> x y z #> 2 2 2 b
df[c(1, 3), ]
#> x y z #> 1 1 3 a #> 3 3 1 c
data.frameDeux approches pour sélectionner les colonnes d’un data.frame.
df <- data.frame(x = 1:3, y = 3:1, z = letters[1:3])
df[c("x", "z")] # approche liste
#> x z #> 1 1 a #> 2 2 b #> 3 3 c
df[, c("x", "z")] # approche matrice
#> x z #> 1 1 a #> 2 2 b #> 3 3 c
data.frameAttention, ces deux approches ne sont pas tout à fait équivalentes.
str(df["x"])
#> 'data.frame': 3 obs. of 1 variable: #> $ x: int 1 2 3
str(df[, "x"])
#> int [1:3] 1 2 3
str(df[, "x", drop = FALSE])
#> 'data.frame': 3 obs. of 1 variable: #> $ x: int 1 2 3
Corriger les erreurs dans les codes suivants.
mtcars[mtcars$cyl = 4, ] mtcars[-1:4, ] mtcars[mtcars$cyl <= 5] mtcars[mtcars$cyl == 4 | 6, ]
Pourquoi le code suivant renvoi cinq valeurs manquantes ? Et avec x[NA_real_] ?
x <- 1:5 x[NA]
#> [1] NA NA NA NA NA
Pourquoi mtcars[1:20] produit une erreur alors que mtcars[1:20, ] fonctionne ? Quelle est la différence ?
Que fait df[is.na(df)] <- 0 ? Sur quel principe repose cette commande ?
[[ et $[[ renvoi toujours un élément plus petit.
x <- list(1:3, "a", 4:6) x[1]
#> [[1]] #> [1] 1 2 3
x[[1]]
#> [1] 1 2 3
[[ et $$ fonctionne d’une façon proche de celle de [[.
mitcars$cyl mitcars[["cyl"]]
[[ et $Le $ n’est pas utilisable lorsque le nom de la colonne ou de l’élément est stockée dans une variable.
var <- "cyl" mtcars$var
#> NULL
mtcars[[var]]
#> [1] 6 6 4 6 8 6 8 4 4 6 6 8 8 8 8 8 8 4 4 4 4 8 8 8 8 4 4 4 8 6 8 4
[[ et $L’opérateur $ permet également une correspondance partiel des noms, contrairement à [[ (ou [).
x <- list(abc = 1) x$a
#> [1] 1
x[["a"]]
#> NULL
slot() et @Les opérateurs slot() et @ sont des opérateurs spécifiques des objets de classe S4, ou slot() correspond à [[ et @ à $.
Extraire la troisième valeur de la variable cyl du jeu de données mtcars.
À partir de la régression linéaire mod <- lm(mpg ~ wt, data = mtcars), extraire le nombre de degré de liberté. Puis extraire, le R carré du modèle (summary(mod)).
Les opérateurs [, [[ et $ permettent également les affectations ou modifications.
x <- 1:5 x[c(1, 2)] <- c(101, 102) x
#> [1] 101 102 3 4 5
Attention au recyclage des valeurs !
Approche identique pour les listes.
x <- list(a = 1, b = 2) x[["b"]] <- NULL y <- list(a = 1, b = 2) y["b"] <- list(NULL) str(y)
#> List of 2 #> $ a: num 1 #> $ b: NULL
Le cas de la sélection par “rien”, c’est-à-dire, df[], permet dans le cas d’une affectation de préservé la structure d’origine.
mtcars[] <- lapply(mtcars, as.integer) is.data.frame(mtcars)
#> [1] TRUE
mtcars <- lapply(mtcars, as.integer) is.data.frame(mtcars)
#> [1] FALSE
Ajouter une colonne cyl_fct à mtcars comme une copie de la colonne cyl. Quel est le type de la nouvelle colonne ? Modifier le type de cette colonne dans un type plus approprié pour une analyse de comparaison de groupes défini par cyl_fct.
Reprendre les fonctions vu au préalable et identifier la structure, le type, la classe et les attributs des objets générés par ces fonctions, p.ex., stats::lm(), stats::aov(), t.test(), ggplot2::ggplot(), etc.
Manipuler les fonctions str(), typeof(), dput(), attributes(), attr(), dimnames(), dim(), rownames(), colnames() et names() sur les jeux de données de datasets (ls(name = "package:datasets")).
Créer une liste, un vecteur, un data.frame à l’aide de la fonction structure().
Une fonction se décompose en trois éléments :
arguments).body).environment).f <- function(x, y) {
# Commentaire
return(x + y)
}
f <- function(x, y) {
# Commentaire
x + y
}
formals(f)
#> $x #> #> #> $y
body(f)
#> {
#> x + y
#> }
environment(f)
#> <environment: 0x563d9bdf5e98>
Les fonctions sont des objets au même titre que les vecteurs.
attributes(f)
#> $srcref
#> function(x, y) {
#> # Commentaire
#> x + y
#> }
f <- function(x, y) {
# Commentaire
x + y
}
f(1, 2)
#> [1] 3
(function(x, y) x + y)(1, 2)
#> [1] 3
square <- function(x) x^2 deviation <- function(x) x - mean(x) x <- runif(100)
sqrt(mean(square(deviation(x))))
#> [1] 0.2808312
out <- deviation(x) out <- square(out) out <- mean(out) out <- sqrt(out) out
#> [1] 0.2808312
%>% (magrittr)library(magrittr) x %>% deviation() %>% square() %>% mean() %>% sqrt()
#> [1] 0.2808312
match.fun() permet de trouver une fonction avec son nom. À partir d’une fonction, est-il possible de trouver son nom ?
Quelles fonctions permettraient d’identifier si un objet est une fonction et s’il s’agit d’une primitive ? Par exemple, +, sum, lm et t.test.
Quelles sont les composantes d’une fonction ?